// 获取所有榜单的容器
const rankLists = document.querySelectorAll('.rlist');
const integralRank = rankLists[0];  // 积分榜
const monthlyRank = rankLists[1];  // 月票榜
const rewardRank = rankLists[2];   // 打赏榜

// 为每个榜单维护一个当前激活项
let activeItems = {
    integral: null,
    monthly: null,
    reward: null
};

// 渲染榜单的通用函数
function renderRankList(ul, data, rankType) {
    data.forEach(item => {
        ul.innerHTML += `
            <li class="listitem">
                <div class="rectbg">
                    <em class="num">0${item.topNum}</em>
                    <span class="bookName">${item.story.name}</span>
                    <span class="author">${item.story.author}</span>
                </div>
                <div class="rectbg2" style="display: none;">
                    <em class="numbg">0${item.topNum}</em>
                    <div class="desc">
                        <span class="bookNamebg">${item.story.name}</span>
                        <span class="authorbg">
                            <i>${item.story.type}
                                | 
                            </i>
                            ${item.story.author}
                        </span>
                    </div>
                    <img src="${item.story.smallCover}" alt="">
                </div>
            </li>
        `;
    });

    // 为列表项添加事件监听器
    const listItems = ul.querySelectorAll('.listitem');
    listItems.forEach(item => {
        item.addEventListener('mouseenter', () => {
            const rectbg = item.querySelector('.rectbg');
            const rectbg2 = item.querySelector('.rectbg2');
            
            // 如果该榜单有其他激活项，先将其恢复为初始状态
            if (activeItems[rankType]) {
                const prevRectbg = activeItems[rankType].querySelector('.rectbg');
                const prevRectbg2 = activeItems[rankType].querySelector('.rectbg2');
                if (prevRectbg && prevRectbg2) {
                    prevRectbg.style.display = 'flex';
                    prevRectbg2.style.display = 'none';
                }
            }
            
            // 激活当前项
            rectbg.style.display = 'none';
            rectbg2.style.display = 'flex';
            activeItems[rankType] = item;
        });
    });

    // 默认激活第一个列表项
    if (listItems.length > 0) {
        const firstItem = listItems[0];
        const firstRectbg = firstItem.querySelector('.rectbg');
        const firstRectbg2 = firstItem.querySelector('.rectbg2');
        firstRectbg.style.display = 'none';
        firstRectbg2.style.display = 'flex';
        activeItems[rankType] = firstItem;
    }
}

// 积分榜
axios.get('https://www.iceread.com/api/common/rank/6276/0/5?cb=1756088109274')
    .then(res => {
        renderRankList(integralRank, res.data.list, 'integral');
    })
    .catch(err => {
    });

// 月票榜
axios.get('https://www.iceread.com/api/common/rank/6264/3/5?cb=1756122011778')
    .then(res => {
        renderRankList(monthlyRank, res.data.list, 'monthly');
    })
    .catch(err => {
    });

// 打赏榜
axios.get('https://www.iceread.com/api/common/rank/6275/0/5?cb=1756122011780')
    .then(res => {
        renderRankList(rewardRank, res.data.list, 'reward');
    })
    .catch(err => {
    });

const contentTagItem = document.querySelector('.filtrateRect .item:nth-child(2)');
const allhide = contentTagItem.querySelectorAll('.hide');
const toggleButton = contentTagItem.querySelector('.foor');

let bol=false; 
out=()=>{
    if(bol) {
        allhide.forEach(item=>{
            item.classList.add('hide');
            toggleButton.textContent = '展开';
            document.querySelector('.c1').style.height='100%'
            
            bol=false;
        });
    }else{
        allhide.forEach(item=>{
            item.classList.remove('hide');
            toggleButton.textContent = '收起';
            document.querySelector('.c1').style.height='76px'
            bol=true;
        });

    }
}
//书库总数据
// let allStories = [];
// let currentPage = 1;
// const itemsPerPage = 20;

// // 渲染书籍列表的函数
// function renderStoryList(stories) {
//     const contentContainer = document.querySelector('.content .ranklist');
//     if (contentContainer) {
//         contentContainer.innerHTML = '';
        
//         stories.forEach(story => {
//             // 处理标签数据，生成标签HTML
//             let tagsHtml = '';
            
//             // 如果story有tags属性且是数组，则使用数组中的标签
//             if (story.tags && Array.isArray(story.tags)) {
//                 story.tags.forEach(tag => {
//                     tagsHtml += `<span class="tag-item">${tag}</span>`;
//                 });
//             } 
//             // 如果story没有tags属性但有tag字符串，则处理字符串中的标签
//             else if (story.tag && typeof story.tag === 'string') {
//                 // 使用逗号分割标签字符串
//                 const tagArray = story.tag.split(',');
//                 tagArray.forEach(tag => {
//                     // 去除每个标签的首尾空格
//                     const cleanTag = tag.trim();
//                     if (cleanTag) {
//                         tagsHtml += `<span class="tag-item">${cleanTag}</span>`;
//                     }
//                 });
//             }
            
//             // 如果没有标签，显示默认内容
//             if (!tagsHtml) {
//                 tagsHtml = '<span class="tag-item">暂无标签</span>';
//             }
            
//             // 创建书籍项HTML
//             const storyHtml = `
//                 <li class="rankitem">
//                     <div class="leftimg">
//                         <img src="${story.smallCover || ''}" alt="${story.name || ''}">
//                         <div class="num"></div>
//                     </div>
//                     <div class="rightrank">
//                         <div class="alltop">
//                             <div class="title">
//                                 <h4>
//                                     ${story.name || ''}
//                                     <em>${story.status === 1 ? '连载中' : story.status === 2 ? '已完本' : ''}</em>
//                                 </h4>
//                             </div>
//                             <div class="author">
//                                 <i class="cover"></i>
//                                 <span>${story.author || ''}</span>
//                                 |
//                                 <span>${story.type || ''}</span>
//                             </div>
//                             <p>${story.introduce || ''}</p>
//                         </div>
//                         <div class="tag">
//                             ${tagsHtml}
//                         </div>
//                     </div>
//                 </li>
//             `;
            
//             contentContainer.innerHTML += storyHtml;
//         });
//     }
// }

// //书库总数据
// axios.get('https://www.iceread.com/api/common/rank/6273/0/1291')
//     .then(res => {
//         console.log(res.data.list);
//         // 存储所有数据
//         allStories = res.data.list.map(item => item.story);
        
//         // 初始化第一页显示
//         displayPage(1);
        
//         // 使用layui创建分页控件
//         layui.use('laypage', function(){
//             var laypage = layui.laypage;
            
//             //执行一个laypage实例
//             laypage.render({
//                 elem: 'demo-laypage-normal-2',
//                 count: allStories.length,
//                 limit: itemsPerPage,
//                 first: '首页',
//                 last: '尾页',
//                 prev: '<em>←</em>',
//                 next: '<em>→</em>',
//                 jump: function(obj, first){
//                     //obj包含了当前分页的所有参数，比如：
//                     console.log(obj.curr); //得到当前页，以便向服务端请求对应页的数据。
//                     console.log(obj.limit); //得到每页显示的条数
                    
//                     //首次不执行
//                     if(!first){
//                         displayPage(obj.curr);
//                     } else {
//                         // 初始化时设置当前页
//                         currentPage = obj.curr;
//                     }
//                 }
//             });
//         });
//     })
//     .catch(err => {
//         console.error(err);
//     });

// // 显示指定页的数据
// function displayPage(pageNumber) {
//     const startIndex = (pageNumber - 1) * itemsPerPage;
//     const endIndex = startIndex + itemsPerPage;
//     const pageStories = allStories.slice(startIndex, endIndex);
    
//     // 渲染当前页的数据
//     renderStoryList(pageStories);
    
//     currentPage = pageNumber;
// }

let allStories = [];
let currentPage = 1;
const itemsPerPage = 20;

// 存储分类过滤条件
let currentFilter = {
    category: '全部', // 书籍分类
    tag: '全部',      // 内容标签
    status: '全部',   // 写作状态
    charge: '全部',   // 收费状态
    sort: '更新时间'  // 排序依据
};

// 渲染书籍列表的函数
function renderStoryList(stories) {
    const contentContainer = document.querySelector('.content .ranklist');
    if (contentContainer) {
        contentContainer.innerHTML = '';
        
        stories.forEach(story => {
            // 处理标签数据，生成标签HTML
            let tagsHtml = '';
            
            // 如果story有tags属性且是数组，则使用数组中的标签
            if (story.tags && Array.isArray(story.tags)) {
                story.tags.forEach(tag => {
                    tagsHtml += `<span class="tag-item">${tag}</span>`;
                });
            } 
            // 如果story没有tags属性但有tag字符串，则处理字符串中的标签
            else if (story.tag && typeof story.tag === 'string') {
                // 使用逗号分割标签字符串
                const tagArray = story.tag.split(',');
                tagArray.forEach(tag => {
                    // 去除每个标签的首尾空格
                    const cleanTag = tag.trim();
                    if (cleanTag) {
                        tagsHtml += `<span class="tag-item">${cleanTag}</span>`;
                    }
                });
            }
            
            // 如果没有标签，显示默认内容
            if (!tagsHtml) {
                tagsHtml = '<span class="tag-item">暂无标签</span>';
            }
            
            // 创建书籍项HTML
            const storyHtml = `
                <li class="rankitem">
                    <div class="leftimg">
                        <img src="${story.smallCover || ''}" alt="${story.name || ''}">
                        <div class="num"></div>
                    </div>
                    <div class="rightrank">
                        <div class="alltop">
                            <div class="title">
                                <h4>
                                    ${story.name || ''}
                                    <em>${story.status === 1 ? '连载中' : story.status === 2 ? '已完本' : ''}</em>
                                </h4>
                            </div>
                            <div class="author">
                                <i class="cover"></i>
                                <span>${story.author || ''}</span>
                                |
                                <span>${story.type || ''}</span>
                            </div>
                            <p>${story.introduce || ''}</p>
                        </div>
                        <div class="tag">
                            ${tagsHtml}
                        </div>
                    </div>
                </li>
            `;
            
            contentContainer.innerHTML += storyHtml;
        });
    }
}

// 过滤和排序函数
function filterAndSortStories() {
    let filteredStories = [...allStories];
    
    // 根据分类过滤
    if (currentFilter.category !== '全部') {
        filteredStories = filteredStories.filter(story => {
            return story.type === currentFilter.category;
        });
    }
    
    // 根据内容标签过滤
    if (currentFilter.tag !== '全部') {
        filteredStories = filteredStories.filter(story => {
            // 检查story是否有tags属性且是数组
            if (story.tags && Array.isArray(story.tags)) {
                return story.tags.includes(currentFilter.tag);
            }
            // 检查story是否有tag字符串
            else if (story.tag && typeof story.tag === 'string') {
                const tagArray = story.tag.split(',');
                return tagArray.some(t => t.trim() === currentFilter.tag);
            }
            return false;
        });
    }
    
    // 根据写作状态过滤
    if (currentFilter.status !== '全部') {
        filteredStories = filteredStories.filter(story => {
            return story.status === (currentFilter.status === '完本' ? 2 : 1);
        });
    }
    
    // 根据收费状态过滤
    if (currentFilter.charge !== '全部') {
        filteredStories = filteredStories.filter(story => {
            // 根据allowPay字段判断收费状态
            if (currentFilter.charge === '免费') {
                return !story.allowPay; // allowPay为false时是免费
            } else if (currentFilter.charge === '收费') {
                return story.allowPay; // allowPay为true时是收费
            }
            return true;
        });
    }
    
    // 根据排序依据排序
    if (currentFilter.sort === '人气') {
        // 根据fireValue（热度）进行排序，数值越大越靠前
        filteredStories.sort((a, b) => b.fireValue - a.fireValue);
    } else if (currentFilter.sort === '更新时间') {
        // 根据latestChapterTime（最新章节时间）进行排序，时间越新越靠前
        filteredStories.sort((a, b) => new Date(b.latestChapterTime) - new Date(a.latestChapterTime));
    } else {
        // 默认按更新时间倒序排列
        filteredStories.sort((a, b) => new Date(b.updateTime) - new Date(a.updateTime));
    }
    
    return filteredStories;
}

// 显示指定页的数据
function displayPage(pageNumber) {
    const startIndex = (pageNumber - 1) * itemsPerPage;
    const endIndex = startIndex + itemsPerPage;
    
    // 获取过滤和排序后的数据
    const filteredStories = filterAndSortStories();
    const pageStories = filteredStories.slice(startIndex, endIndex);
    
    // 渲染当前页的数据
    renderStoryList(pageStories);
    
    currentPage = pageNumber;
}

// 书库总数据
axios.get('https://www.iceread.com/api/common/rank/6273/0/1291')
    .then(res => {
        console.log(res.data.list);
        // 存储所有数据
        allStories = res.data.list.map(item => item.story);
        
        // 初始化第一页显示
        displayPage(1);
        
        // 使用layui创建分页控件
        layui.use('laypage', function(){
            var laypage = layui.laypage;
            
            //执行一个laypage实例
            laypage.render({
                elem: 'demo-laypage-normal-2',
                count: allStories.length,
                limit: itemsPerPage,
                theme:'#ff9ab4',
                first: '首页',
                last: '尾页',
                prev: '<em>←</em>',
                next: '<em>→</em>',
                jump: function(obj, first){
                    //obj包含了当前分页的所有参数，比如：
                    console.log(obj.curr); //得到当前页，以便向服务端请求对应页的数据。
                    console.log(obj.limit); //得到每页显示的条数
                    
                    //首次不执行
                    if(!first){
                        displayPage(obj.curr);
                    } else {
                        // 初始化时设置当前页
                        currentPage = obj.curr;
                    }
                }
            });
        });
    })
    .catch(err => {
        console.error('获取数据失败:', err);
    });

// 添加分类切换事件监听器
document.addEventListener('DOMContentLoaded', function() {
    // 书籍分类切换
    const categoryLinks = document.querySelectorAll('.filtrateRect .item:nth-child(1) .a');
    categoryLinks.forEach(link => {
        link.addEventListener('click', function(e) {
            e.preventDefault();
            // 移除所有链接的on类
            categoryLinks.forEach(l => l.classList.remove('on'));
            // 添加当前链接的on类
            this.classList.add('on');
            // 更新过滤条件
            currentFilter.category = this.textContent;
            // 重置到第一页
            currentPage = 1;
            // 重新显示第一页
            displayPage(1);
            // 重新渲染分页控件
            updateLaypage();
        });
    });
    
    // 内容标签切换
    const tagLinks = document.querySelectorAll('.filtrateRect .item:nth-child(2) .a');
    tagLinks.forEach(link => {
        link.addEventListener('click', function(e) {
            e.preventDefault();
            // 移除所有链接的on类
            tagLinks.forEach(l => l.classList.remove('on'));
            // 添加当前链接的on类
            this.classList.add('on');
            // 更新过滤条件
            currentFilter.tag = this.textContent;
            // 重置到第一页
            currentPage = 1;
            // 重新显示第一页
            displayPage(1);
            // 重新渲染分页控件
            updateLaypage();
        });
    });
    
    // 写作状态切换（连载/完本）
    const statusLinks = document.querySelectorAll('.filtrateRect .item:nth-child(3) .a');
    statusLinks.forEach(link => {
        link.addEventListener('click', function(e) {
            e.preventDefault();
            // 移除所有链接的on类
            statusLinks.forEach(l => l.classList.remove('on'));
            // 添加当前链接的on类
            this.classList.add('on');
            // 更新过滤条件
            currentFilter.status = this.textContent;
            // 重置到第一页
            currentPage = 1;
            // 重新显示第一页
            displayPage(1);
            // 重新渲染分页控件
            updateLaypage();
        });
    });
    
    // 收费状态切换（免费/收费）
    const chargeLinks = document.querySelectorAll('.filtrateRect .item:nth-child(4) .a');
    chargeLinks.forEach(link => {
        link.addEventListener('click', function(e) {
            e.preventDefault();
            // 移除所有链接的on类
            chargeLinks.forEach(l => l.classList.remove('on'));
            // 添加当前链接的on类
            this.classList.add('on');
            // 更新过滤条件
            currentFilter.charge = this.textContent;
            // 重置到第一页
            currentPage = 1;
            // 重新显示第一页
            displayPage(1);
            // 重新渲染分页控件
            updateLaypage();
        });
    });
    
    // 排序依据切换
    const sortLinks = document.querySelectorAll('.filtrateRect .item:nth-child(5) .a');
    sortLinks.forEach(link => {
        link.addEventListener('click', function(e) {
            e.preventDefault();
            // 移除所有链接的on类
            sortLinks.forEach(l => l.classList.remove('on'));
            // 添加当前链接的on类
            this.classList.add('on');
            // 更新过滤条件
            currentFilter.sort = this.textContent;
            // 重置到第一页
            currentPage = 1;
            // 重新显示第一页
            displayPage(1);
            // 重新渲染分页控件
            updateLaypage();
        });
    });
});

// 新增函数：更新分页控件
function updateLaypage() {
    layui.use('laypage', function(){
        var laypage = layui.laypage;
        
        // 获取过滤和排序后的数据总数
        const filteredStories = filterAndSortStories();
        const totalCount = filteredStories.length;
        
        // 重新渲染分页控件
        laypage.render({
            elem: 'demo-laypage-normal-2',
            count: totalCount,
            limit: itemsPerPage,
            curr: 1, // 确保从第一页开始
            theme:'#ff9ab4',
            first: '首页',
            last: '尾页',
            prev: '<em>←</em>',
            next: '<em>→</em>',
            jump: function(obj, first){
                //obj包含了当前分页的所有参数，比如：
                console.log(obj.curr); //得到当前页，以便向服务端请求对应页的数据。
                console.log(obj.limit); //得到每页显示的条数
                
                //首次不执行
                if(!first){
                    displayPage(obj.curr);
                } else {
                    // 初始化时设置当前页
                    currentPage = obj.curr;
                }
            }
        });
    });
}

    // 全局变量管理
const searchState = {
    novelData: [], // 存储接口返回的所有小说数据
    filteredData: [], // 筛选后的数据
    debounceTimer: null, // 防抖定时器
    currentKeyword: '', // 当前搜索关键词
    isLoading: false // 加载状态标识
};

// DOM 元素缓存（基于原始 HTML 结构）
const domElements = {
    searchInput: document.getElementById('searchInput'),
    searchBtn: document.getElementById('searchBtn'),
    // 动态创建结果容器（不修改原始 HTML，追加到搜索框下方）
    resultContainer: (() => {
        const container = document.createElement('div');
        container.id = 'searchResultContainer';
        container.style.cssText = `
            position: absolute;
            top: 100%;
            left: 0;
            right: 0;
            margin-top: 8px;
            background: #fff;
            border-radius: 8px;
            box-shadow: 0 4px 16px rgba(0,0,0,0.1);
            z-index: 100;
            max-height: 400px;
            overflow-y: auto;
            display: none;
        `;
        // 将结果容器插入到搜索框父元素中
        document.querySelector('.search-content').appendChild(container);
        return container;
    })()
};

// 初始化：加载小说数据并绑定事件
async function initSearch() {
    // 优先加载接口数据
    await fetchNovelData();
    // 绑定交互事件
    bindSearchEvents();
}

// 调用小说接口获取数据
async function fetchNovelData() {
    try {
        const response = await fetch('https://www.iceread.com/api/common/rank/6273/0/1291');
        if (!response.ok) throw new Error('接口请求失败');
        
        const data = await response.json();
        // 提取小说核心数据（适配接口返回格式）
        searchState.novelData = data.list ? data.list.map(item => item.story || item) : [];
        searchState.filteredData = [...searchState.novelData];
    } catch (error) {
        console.error('小说数据加载失败:', error);
        renderResult(`<div style="padding:16px;text-align:center;color:#999;">数据加载失败，请稍后重试</div>`);
    }
}

// 绑定搜索相关事件
function bindSearchEvents() {
    // 搜索按钮点击
    domElements.searchBtn.addEventListener('click', handleSearch);
    
    // 输入框实时输入（防抖处理）
    domElements.searchInput.addEventListener('input', () => {
        searchState.currentKeyword = domElements.searchInput.value.trim().toLowerCase();
        
        // 清空关键词时隐藏结果容器
        if (!searchState.currentKeyword) {
            domElements.resultContainer.style.display = 'none';
            return;
        }
        
        // 防抖：300ms 内连续输入不触发搜索
        clearTimeout(searchState.debounceTimer);
        searchState.debounceTimer = setTimeout(handleSearch, 300);
    });
    
    // 回车键触发搜索
    domElements.searchInput.addEventListener('keydown', (e) => {
        if (e.key === 'Enter') handleSearch();
    });
    
    // 点击页面其他区域隐藏结果容器
    document.addEventListener('click', (e) => {
        const isClickInside = domElements.searchInput.contains(e.target) || 
                             domElements.searchBtn.contains(e.target) || 
                             domElements.resultContainer.contains(e.target);
        if (!isClickInside) {
            domElements.resultContainer.style.display = 'none';
        }
    });
}

// 核心搜索逻辑
function handleSearch() {
    const keyword = searchState.currentKeyword;
    
    // 显示加载状态
    showLoading();
    
    // 筛选逻辑：匹配小说名、作者、标签
    searchState.filteredData = searchState.novelData.filter(novel => {
        const matchName = novel.name?.toLowerCase().includes(keyword) || false;
        const matchAuthor = novel.author?.toLowerCase().includes(keyword) || false;
        const matchTag = novel.tag?.toLowerCase().includes(keyword) || false;
        return matchName || matchAuthor || matchTag;
    });
    
    // 渲染搜索结果
    renderResult();
}

// 渲染搜索结果
function renderResult(customContent = '') {
    // 隐藏加载状态
    hideLoading();
    
    // 显示结果容器
    domElements.resultContainer.style.display = 'block';
    
    // 自定义内容渲染（如错误提示）
    if (customContent) {
        domElements.resultContainer.innerHTML = customContent;
        return;
    }
    
    // 无结果处理
    if (searchState.filteredData.length === 0) {
        domElements.resultContainer.innerHTML = `
            <div style="padding:24px;text-align:center;">
                <div style="font-size:24px;color:#ccc;margin-bottom:8px;">&#128270;</div>
                <p style="color:#666;">未找到包含「${searchState.currentKeyword}」的小说</p>
                <p style="color:#999;font-size:12px;margin-top:4px;">建议尝试其他关键词</p>
            </div>
        `;
        return;
    }
    
    // 渲染小说列表
    let resultHtml = '';
    searchState.filteredData.forEach(novel => {
        // 关键词高亮处理
        const highlight = (text) => {
            if (!text || !searchState.currentKeyword) return text;
            const regex = new RegExp(`(${searchState.currentKeyword})`, 'gi');
            return text.replace(regex, '<span style="color:#6366f1;font-weight:500;">$1</span>');
        };
        
        // 小说标签处理
        const tags = novel.tag ? novel.tag.split(',').slice(0, 2) : [];
        const tagHtml = tags.map(tag => `
            <span style="font-size:12px;padding:2px 6px;background:#f3f4f6;color:#666;border-radius:4px;margin-right:4px;">${highlight(tag)}</span>
        `).join('');
        
        // 单个小说项 HTML
        resultHtml += `
            <div style="padding:12px;border-bottom:1px solid #f5f5f5;cursor:pointer;" onmouseover="this.style.background='#fafafa'" onmouseout="this.style.background='transparent'"onclick='jumps(${JSON.stringify(novel)})'>
                <div style="display:flex;justify-content:space-between;align-items:flex-start;margin-bottom:4px;">
                    <h4 style="margin:0;font-size:14px;color:#333;">${highlight(novel.name)}</h4>
                    ${novel.isPay === 1 ? '<span style="font-size:12px;color:#ef4444;background:#fee2e2;padding:1px 4px;border-radius:3px;">VIP</span>' : ''}
                </div>
                <p style="margin:0 0 6px 0;font-size:12px;color:#999;">作者：${highlight(novel.author)}</p>
                <div style="margin-bottom:6px;">${tagHtml}</div>
                <p style="margin:0;font-size:12px;color:#666;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden;">
                    ${highlight(novel.introduce ? novel.introduce.slice(0, 100) + '...' : '暂无简介')}
                </p>
            </div>
        `;
    });
    
    domElements.resultContainer.innerHTML = resultHtml;
}

// 显示加载状态
function showLoading() {
    searchState.isLoading = true;
    domElements.resultContainer.style.display = 'block';
    domElements.resultContainer.innerHTML = `
        <div style="padding:24px;text-align:center;">
            <div style="width:20px;height:20px;border:2px solid #6366f1;border-top-color:transparent;border-radius:50%;animation:spin 1s linear infinite;margin:0 auto 8px;"></div>
            <p style="color:#666;font-size:12px;">正在搜索...</p>
        </div>
    `;
    // 添加加载动画样式
    const style = document.createElement('style');
    style.textContent = `
        @keyframes spin {
            0% { transform: rotate(0deg); }
            100% { transform: rotate(360deg); }
        }
    `;
    document.head.appendChild(style);
}

// 隐藏加载状态
function hideLoading() {
    searchState.isLoading = false;
}

// 页面加载完成后初始化搜索功能
document.addEventListener('DOMContentLoaded', initSearch);

    function jumps(hearf){
       location.href=`./channelDetail.html?${JSON.stringify(hearf)}`
    }
    function jumpShouye(){
        location.href=`./index.html`
    }
    function login(){
        location.href=`./personal.html`
    }
    function jumpGirlCopyRight(){
        location.href=`./girlCopyright.html`
    }
    function jumpAuthor(){
        location.href='./personal.html?'
    }
    function jumpNvbook(){
        location.href=`./channelBook.html`
    }
    function jumpNvrank(){
        location.href=`./channelRank.html`
    }
    function jumpNv(){
        location.href=`./channel.html`
    }